package system_service

import (
	"errors"
	"fmt"
	"github.com/APP/global"
	"github.com/APP/internal/models"
	"gorm.io/gorm"
	"time"
)

type DictService struct{}

// CreateDict 创建字典类型
func (s *DictService) CreateDict(dict *models.SysDict) (*models.SysDict, error) {
	// 检查字典类型是否已存在
	var existingDict models.SysDict
	if err := global.APP_DB.Where("dict_type = ? AND deleted_at IS NULL", dict.DictType).First(&existingDict).Error; err == nil {
		return nil, errors.New("字典类型已存在")
	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fmt.Errorf("检查字典类型失败: %v", err)
	}

	if err := global.APP_DB.Create(dict).Error; err != nil {
		return nil, fmt.Errorf("创建字典类型失败: %v", err)
	}

	return dict, nil
}

// UpdateDict 更新字典类型
func (s *DictService) UpdateDict(dict *models.SysDict) (*models.SysDict, error) {
	// 检查字典是否存在
	var existingDict models.SysDict
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", dict.ID).First(&existingDict).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("字典类型不存在")
		}
		return nil, fmt.Errorf("查询字典类型失败: %v", err)
	}

	// 更新字段
	updates := map[string]interface{}{
		"dict_name":    dict.DictName,
		"type":         dict.Type,
		"allow_extend": dict.AllowExtend,
		"status":       dict.Status,
		"remark":       dict.Remark,
		"update_user":  dict.UpdateUser,
		"update_time":  dict.UpdateTime,
	}

	if err := global.APP_DB.Model(&existingDict).Updates(updates).Error; err != nil {
		return nil, fmt.Errorf("更新字典类型失败: %v", err)
	}

	// 重新查询更新后的数据
	if err := global.APP_DB.Where("id = ?", dict.ID).First(&existingDict).Error; err != nil {
		return nil, fmt.Errorf("查询更新后的字典类型失败: %v", err)
	}

	return &existingDict, nil
}

// DeleteDict 删除字典类型（软删除）
func (s *DictService) DeleteDict(id int) error {
	// 检查字典是否存在
	var dict models.SysDict
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", id).First(&dict).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("字典类型不存在")
		}
		return fmt.Errorf("查询字典类型失败: %v", err)
	}

	// 检查是否有关联的字典数据
	var count int64
	if err := global.APP_DB.Model(&models.SysDictData{}).Where("dict_type = ? AND deleted_at IS NULL", dict.DictType).Count(&count).Error; err != nil {
		return fmt.Errorf("检查关联字典数据失败: %v", err)
	}

	if count > 0 {
		return errors.New("该字典类型下还有字典数据，无法删除")
	}

	// 软删除
	now := time.Now()
	if err := global.APP_DB.Model(&dict).Update("deleted_at", now).Error; err != nil {
		return fmt.Errorf("删除字典类型失败: %v", err)
	}

	return nil
}

// GetDict 获取字典类型详情
func (s *DictService) GetDict(id int) (*models.SysDict, error) {
	var dict models.SysDict
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", id).First(&dict).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("字典类型不存在")
		}
		return nil, fmt.Errorf("查询字典类型失败: %v", err)
	}

	return &dict, nil
}

// GetDictList 获取字典类型列表
func (s *DictService) GetDictList(page, pageSize int, dictType, dictName string, status *int) ([]*models.SysDict, int64, error) {
	var dicts []*models.SysDict
	var total int64

	query := global.APP_DB.Model(&models.SysDict{}).Where("deleted_at IS NULL")

	// 添加筛选条件
	if dictType != "" {
		query = query.Where("dict_type LIKE ?", "%"+dictType+"%")
	}
	if dictName != "" {
		query = query.Where("dict_name LIKE ?", "%"+dictName+"%")
	}
	if status != nil {
		query = query.Where("status = ?", *status)
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("查询字典类型总数失败: %v", err)
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := query.Order("create_time DESC").Offset(offset).Limit(pageSize).Find(&dicts).Error; err != nil {
		return nil, 0, fmt.Errorf("查询字典类型列表失败: %v", err)
	}
	global.APP_LOG.Info("GetDictList")

	return dicts, total, nil
}

// CreateDictData 创建字典数据
func (s *DictService) CreateDictData(dictData *models.SysDictData) (*models.SysDictData, error) {
	// 检查字典类型是否存在
	var dict models.SysDict
	if err := global.APP_DB.Where("dict_type = ? AND deleted_at IS NULL", dictData.DictType).First(&dict).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("字典类型不存在")
		}
		return nil, fmt.Errorf("查询字典类型失败: %v", err)
	}

	// 检查字典编码是否已存在
	var existingDictData models.SysDictData
	if err := global.APP_DB.Where("dict_type = ? AND dict_code = ? AND deleted_at IS NULL", dictData.DictType, dictData.DictCode).First(&existingDictData).Error; err == nil {
		return nil, errors.New("字典编码已存在")
	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fmt.Errorf("检查字典编码失败: %v", err)
	}

	if err := global.APP_DB.Create(dictData).Error; err != nil {
		return nil, fmt.Errorf("创建字典数据失败: %v", err)
	}

	return dictData, nil
}

// UpdateDictData 更新字典数据
func (s *DictService) UpdateDictData(dictData *models.SysDictData) (*models.SysDictData, error) {
	// 检查字典数据是否存在
	var existingDictData models.SysDictData
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", dictData.ID).First(&existingDictData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("字典数据不存在")
		}
		return nil, fmt.Errorf("查询字典数据失败: %v", err)
	}

	// 更新字段
	updates := map[string]interface{}{
		"dict_name":   dictData.DictName,
		"sort":        dictData.Sort,
		"status":      dictData.Status,
		"is_default":  dictData.IsDefault,
		"color":       dictData.Color,
		"icon":        dictData.Icon,
		"tag":         dictData.Tag,
		"extend_json": dictData.ExtendJson,
		"remark":      dictData.Remark,
	}

	if err := global.APP_DB.Model(&existingDictData).Updates(updates).Error; err != nil {
		return nil, fmt.Errorf("更新字典数据失败: %v", err)
	}

	// 重新查询更新后的数据
	if err := global.APP_DB.Where("id = ?", dictData.ID).First(&existingDictData).Error; err != nil {
		return nil, fmt.Errorf("查询更新后的字典数据失败: %v", err)
	}

	return &existingDictData, nil
}

// DeleteDictData 删除字典数据（软删除）
func (s *DictService) DeleteDictData(id int) error {
	// 检查字典数据是否存在
	var dictData models.SysDictData
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", id).First(&dictData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("字典数据不存在")
		}
		return fmt.Errorf("查询字典数据失败: %v", err)
	}

	// 软删除
	now := time.Now()
	if err := global.APP_DB.Model(&dictData).Update("deleted_at", now).Error; err != nil {
		return fmt.Errorf("删除字典数据失败: %v", err)
	}

	return nil
}

// GetDictData 获取字典数据详情
func (s *DictService) GetDictData(id int) (*models.SysDictData, error) {
	var dictData models.SysDictData
	if err := global.APP_DB.Where("id = ? AND deleted_at IS NULL", id).First(&dictData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("字典数据不存在")
		}
		return nil, fmt.Errorf("查询字典数据失败: %v", err)
	}

	return &dictData, nil
}

// GetDictDataList 获取字典数据列表
func (s *DictService) GetDictDataList(page, pageSize int, dictType, dictCode, dictName string, status *int) ([]*models.SysDictData, int64, error) {
	var dictDataList []*models.SysDictData
	var total int64

	query := global.APP_DB.Model(&models.SysDictData{}).Where("deleted_at IS NULL")

	// 添加筛选条件
	if dictType != "" {
		query = query.Where("dict_type = ?", dictType)
	}
	if dictCode != "" {
		query = query.Where("dict_code LIKE ?", "%"+dictCode+"%")
	}
	if dictName != "" {
		query = query.Where("dict_name LIKE ?", "%"+dictName+"%")
	}
	if status != nil {
		query = query.Where("status = ?", *status)
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("查询字典数据总数失败: %v", err)
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := query.Order("sort ASC, created_at DESC").Offset(offset).Limit(pageSize).Find(&dictDataList).Error; err != nil {
		return nil, 0, fmt.Errorf("查询字典数据列表失败: %v", err)
	}

	return dictDataList, total, nil
}

// GetDictDataByType 根据字典类型获取字典数据
func (s *DictService) GetDictDataByType(dictType string) ([]*models.SysDictData, error) {
	var dictDataList []*models.SysDictData

	if err := global.APP_DB.Where("dict_type = ? AND status = 1 AND deleted_at IS NULL", dictType).
		Order("sort ASC, created_at DESC").Find(&dictDataList).Error; err != nil {
		return nil, fmt.Errorf("查询字典数据失败: %v", err)
	}

	return dictDataList, nil
}

// GetDictTypes 获取所有字典类型
func (s *DictService) GetDictTypes() ([]*models.SysDictType, error) {
	var dictTypes []*models.SysDictType

	if err := global.APP_DB.Find(&dictTypes).Error; err != nil {
		return nil, fmt.Errorf("查询字典类型失败: %v", err)
	}

	return dictTypes, nil
}
